home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / program / misc / fpl-v13.lha / fpl / src / liballoc.a < prev    next >
Text File  |  1994-10-08  |  9KB  |  284 lines
  1.  ******************************************************************************
  2.  *              FREXX PROGRAMMING LANGUAGE                  *
  3.  ******************************************************************************
  4.  
  5.  * liballoc.a
  6.  
  7.  * Stack allocation/checking/expanding routines.
  8.  
  9.  * Authors: Kjell Ericson and Daniel Stenberg
  10.  
  11.  ******************************************************************************
  12.  
  13.  ************************************************************************
  14.  *                                                                      *
  15.  * fpl.library - A shared library interpreting script langauge.         *
  16.  * Copyright (C) 1992-1994 FrexxWare                                    *
  17.  * Author: Daniel Stenberg                                              *
  18.  *                                                                      *
  19.  * This program is free software; you may redistribute for non          *
  20.  * commercial purposes only. Commercial programs must have a written    *
  21.  * permission from the author to use FPL. FPL is *NOT* public domain!   *
  22.  * Any provided source code is only for reference and for assurance     *
  23.  * that users should be able to compile FPL on any operating system     *
  24.  * he/she wants to use it in!                                           *
  25.  *                                                                      *
  26.  * You may not change, resource, patch files or in any way reverse      *
  27.  * engineer anything in the FPL package.                                *
  28.  *                                                                      *
  29.  * This program is distributed in the hope that it will be useful,      *
  30.  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
  31.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                 *
  32.  *                                                                      *
  33.  * Daniel Stenberg                                                      *
  34.  * Ankdammsgatan 36, 4tr                                                *
  35.  * S-171 43 Solna                                                       *
  36.  * Sweden                                                               *
  37.  *                                                                      *
  38.  * FidoNet 2:201/328    email:dast@sth.frontec.se                       *
  39.  *                                                                      *
  40.  ************************************************************************
  41.  
  42.     ; LibAlloc.a
  43.     ;
  44.     ; Allocate and expands the stack at need. a6 is always the FPLBase
  45.     ; pointer when any of these routine are called!
  46.  
  47.     CSECT    LibAlloc
  48.  
  49.     xdef    _GetStackUsed    ; long GetStackUsed(struct Data *);
  50.     xdef    _InitStack    ; void InitStack(struct Data *)
  51.     xdef    _CheckStack    ; long OK= CheckStack(struct Data *,
  52.                 ;              long maxstack,
  53.                 ;              long minstack);
  54.     xdef    _InterfaceCall    ; long InterfaceCall(struct Data *,
  55.                 ;             void **);
  56.                 ;             func pointer);
  57.     xdef    _InterfaceCallNoStack ; long InterfaceCallNoStack(
  58.                 ;             struct Data *,
  59.                 ;             void **);
  60.                 ;             func pointer);
  61.     xdef    _StoreRegisters ; void StoreRegisters(stuct Data *);
  62.     xref    _Script        ; call this function!
  63.  
  64.     xref    _Malloc        ; malloc routine
  65.     xref    _Free        ; free routine
  66.  
  67.     IFD    LOCKFUNTIONS_WANTED
  68.  
  69.     xdef    _Locker        ; void Locker(long *data, char bit);
  70.     xdef    _Unlocker    ; void Unlocker(long *data, char bit);
  71.  
  72.     ENDC
  73.  
  74.     include "exec/memory.i"
  75.     include "exec/tasks.i"
  76.     include "liballoc.i"
  77.  
  78. asALLOCSTACK equ 5000    ; Number of bytes added to current size when reallocing
  79. asINITCOPY equ 100    ; Amout of memory copied from stack (even 4)
  80. MALLOC_STATIC equ 1    ; Static allocation type specifier
  81.  
  82. _InitStack: ; struct Data * in A2
  83.         ; struct Expr * in A3
  84.         ; short control in D2
  85.         ; struct Condition * in A1
  86.  
  87.     move.l    sp,DATA_EXT_STACK(a2)    ; store external stack pointer
  88.     move.l    DATA_INT_STACK(a2),sp    ; internal stack pointer in A0
  89.  
  90.     move.l    DATA_TASK(a2),a0    ; get task pointer in A0
  91.  
  92.     move.l    TC_SPUPPER(a0),DATA_OLDTOP(a2)    ; upper
  93.     move.l    TC_SPLOWER(a0),DATA_OLDBOT(a2)    ; lower
  94.  
  95.     move.l    DATA_STACKBASE(a2),d0    ; get stack base in D0
  96.     add.l    DATA_STACKSIZE(a2),d0    ; add stack size
  97.     move.l    d0,TC_SPUPPER(a0)    ; set new stack upper bound
  98.  
  99.     move.l    DATA_STACKBASE(a2),TC_SPLOWER(a0)    ; set new stack lower bound
  100.  
  101.     bsr    _Script        ; don't mess with D0!!
  102.  
  103.     move.l    DATA_TASK(a2),a0        ; get task pointer in A0
  104.     move.l    TC_SPLOWER(a0),DATA_STACKBASE(a2)    ; get new stack lower bound
  105.  
  106.     move.l    DATA_OLDBOT(a2),TC_SPLOWER(a0)    ; set lower bounds
  107.     move.l    DATA_OLDTOP(a2),TC_SPUPPER(a0)    ; set upper bounds
  108.  
  109.     move.l    sp,DATA_INT_STACK(a2)        ; store internal stack pointer
  110.     move.l    DATA_EXT_STACK(a2),sp        ; external stack pointer
  111.  
  112.     rts
  113.  
  114. _GetStackUsed: ;(struct Data * - A0)
  115.     move.l    a1,-(sp)        ; backup A1
  116.     move.l    DATA_STACKBASE(a0),a1    ; stack base address
  117.     move.l    sp,d0            ; get stack pointer to d0
  118.     sub.l    a1,d0            ; subtract stack base pointer
  119.     move.l    (sp)+,a1        ; restore A1
  120.     rts
  121.  
  122. _CheckStack: ;(struct Data * - A3; stack limit - D2 ; stack margin - D3)
  123.     movem.l    d1/a0/a1/a2,-(sp)    ; [PUSH]
  124.  
  125.     move.l    DATA_STACKBASE(a3),a0    ; stack base address in A0
  126.  
  127.     move.l    sp,d0            ; stack pointer in D0
  128.     sub.l    a0,d0            ; subtract stack base
  129.     cmp.l    d3,d0             ; stack usage larger than margin?
  130.     bpl    csend             ; no? return!
  131.     move.l    DATA_STACKSIZE(a3),d0    ; current stack size to D0
  132.  
  133.     add.l    d3,d0            ; add margin size to stack size
  134.  
  135.     cmp.l    d0,d2            ; Compare with the stack limit
  136.  
  137.     bmi    csend3    ; reached stack limit, fail!
  138.  
  139.     movem.l    d0/a0,-(sp)        ; size in D0 [PUSH]
  140.     move.b    #MALLOC_STATIC,d1    ; type
  141.     move.l    a3,a0            ; struct Data *
  142.     IFD    DEBUG
  143.     lea.l    sourcename,a1
  144.     clr.l    d2
  145.     ENDC
  146.     jsr    _Malloc            ; get memory
  147.     movem.l    (sp)+,d1/a0        : [POP] size is now in D1
  148.  
  149.     tst.l    d0            ; Did we get memory?
  150.     beq.s    csend2            ; no memory, fail!
  151.     move.l    d0,a2            ; memory pointer (stack base) in A2
  152.     move.l    d1,DATA_STACKSIZE(a3)    ; store size in Data struct!
  153.  
  154.     move.l    d1,d0            ; get new size in D0
  155.     sub.l    d3,d0            ; subtract the addition to get old
  156.  
  157.     movem.l    a2/a3,-(sp)        ; [PUSH]
  158.     move.l    a0,a1            ; old stack base to A1
  159.     sub.l    d0,a2            ; subtract old size from new base
  160.     add.l    d1,a2            ; add new size to new base
  161.                 ; old size is in D0
  162.     sub.l    #4,d0            ; count down four bytes now
  163.  
  164. cslo1:    move.l    (a1)+,(a2)+        ; move
  165.     sub.l    #4,d0
  166.     bpl.s    cslo1            ; while positive, loop!
  167.  
  168.     movem.l    (sp)+,a2/a3        ; [POP]
  169.     move.l    sp,a1            ; stack pointer to A1
  170.     sub.l    a0,a1            ; subtract old stack base
  171.     add.l    a2,a1            ; add new stack base
  172.     add.l    d3,a1            ; add margin size
  173. ;    add.l    #asALLOCSTACK,a1    ; add stack realloc size
  174.     move.l    a1,sp            ; SET NEW STACK POINTER!!!
  175.  
  176.     move.l    DATA_TASK(a3),a1    ; get task pointer in A1
  177.  
  178.     move.l    a2,d0            ; get stack base in D0
  179.     add.l    DATA_STACKSIZE(a3),d0    ; add stack size
  180.     move.l    d0,TC_SPUPPER(a1)    ; set new stack upper bound
  181.  
  182.     move.l    a2,TC_SPLOWER(a1)    ; set new stack lower bound
  183.  
  184.             ; Deallocate old stack
  185.     movem.l    a2/a3,-(sp)        ; [PUSH]
  186.  
  187.     move.l    a0,a1            ; memory pointer to A1
  188.     move.l    a3,a0            ; struct Data * to A0
  189.     move.b    #MALLOC_STATIC,d0    ; type to D0
  190.     jsr    _Free
  191.     movem.l    (sp)+,a2/a3        ; [POP]
  192.  
  193.     move.l    a2,DATA_STACKBASE(a3)    ; Store the new value
  194. csend:            ; OK
  195.     moveq.l    #0,d0
  196.     movem.l    (sp)+,d1/a0/a1/a2    ; [POP]
  197.     rts
  198. csend2:            ; OUT OF MEM
  199.     moveq.l    #1,d0
  200.     movem.l    (sp)+,d1/a0/a1/a2    ; [POP]
  201.     rts
  202. csend3:            ; MAX STACK REACHED
  203.     moveq.l    #2,d0
  204.     movem.l    (sp)+,d1/a0/a1/a2    ; [POP]
  205.     rts
  206.  
  207.  
  208. _InterfaceCall: ; struct Data * in A1
  209.         ; void * in A0
  210.         ; function pointer in A2
  211.  
  212.     movem.l    d2-d7/a1/a3-a6,-(sp)        ; store registers
  213.     move.l    DATA_TASK(a1),a3
  214.  
  215.     move.l    DATA_OLDTOP(a1),TC_SPUPPER(a3)    ; upper
  216.     move.l    DATA_OLDBOT(a1),TC_SPLOWER(a3)    ; lower
  217.     move.l    sp,DATA_INT_STACK(a1)        ; set internal pointer
  218.     move.l    DATA_EXT_STACK(a1),sp        ; set external pointer
  219.  
  220.     lea    DATA_REGISTERSTORAGE(a1),a3 ; get register buffer
  221.     move.l    a1,-(sp)            ; store struct Data *
  222.     movem.l    (a3),d2-d7/a3-a6        ; get registers from buffer
  223.     jsr    (a2)                ; call interface function
  224.         ; DON'T MESS WITH D0!!!
  225.  
  226.     move.l    (sp)+,a1            ; get struct Data * in A1
  227.  
  228.     move.l    sp,DATA_EXT_STACK(a1)
  229.     move.l    DATA_INT_STACK(a1),sp
  230.  
  231.     move.l    DATA_TASK(a1),a2
  232.     move.l    TC_SPUPPER(a2),DATA_OLDTOP(a1)    ; upper
  233.     move.l    TC_SPLOWER(a2),DATA_OLDBOT(a1)    ; lower
  234.  
  235.     move.l    DATA_STACKBASE(a1),d1    ; get stack base in D1
  236.     move.l    d1,TC_SPLOWER(a2)    ; set new stack lower bound
  237.     add.l    DATA_STACKSIZE(a1),d1    ; add stack size
  238.     move.l    d1,TC_SPUPPER(a2)    ; set new stack upper bound
  239.  
  240.     movem.l    (sp)+,d2-d7/a1/a3-a6        ; restore old registers
  241.     rts
  242.  
  243. _InterfaceCallNoStack: ; struct Data * in A1
  244.         ; void * in A0
  245.         ; function pointer in A2
  246.  
  247.     movem.l    d2-d7/a1/a3-a6,-(sp)        ; store registers
  248.     lea    DATA_REGISTERSTORAGE(a1),a3 ; get register buffer
  249.     movem.l    (a3),d2-d7/a3-a6        ; get registers from buffer
  250.     jsr    (a2)                ; call interface function
  251.         ; DON'T MESS WITH D0!!!
  252.     movem.l    (sp)+,d2-d7/a1/a3-a6        ; restore old registers
  253.     rts
  254.  
  255. _StoreRegisters: ; struct Data * in A0
  256.     lea    DATA_REGISTERSTORAGE(a0),a0    ; get register buffer address
  257.     movem.l    d2-d7/a3-a6,(a0)        ; store registers in buffer
  258.     rts
  259.  
  260.     IFD    DEBUG
  261. sourcename:
  262.     dc.b    'liballoc.a'
  263.     ENDC
  264.  
  265.  
  266.     IFD    LOCKFUNCTIONS_WANTED
  267.  
  268. _Locker: ; long *data in A0
  269.      ; char bit in D0
  270.  
  271.     bset    d0,(a0)
  272.     bne.s    _Locker
  273.     rts
  274.  
  275. _Unlocker: ; long *data in A0
  276.        ; char bit in D0
  277.  
  278.     bclr    d0,(a0)
  279.     rts
  280.  
  281.     ENDC
  282.  
  283.  END
  284.